// 全局异常处理（在所有模块加载之前）
process.on('uncaughtException', (error) => {
  console.error('=== UNCAUGHT EXCEPTION ===')
  console.error('Error:', error.message)
  console.error('Stack:', error.stack)
  process.exit(1)
})

process.on('unhandledRejection', (reason, promise) => {
  console.error('=== UNHANDLED REJECTION ===')
  console.error('Reason:', reason)
  console.error('Promise:', promise)
  process.exit(1)
})

const express = require('express')
const cors = require('cors')
const helmet = require('helmet')
const compression = require('compression')
const path = require('path')
const fs = require('fs')

// 导入配置和工具
const config = require('./config')
const logger = require('./utils/logger')
const { HTTP_STATUS } = require('./utils/constants')

// 导入中间件
const { errorHandler, notFoundHandler } = require('./middleware/errorHandler')
const { corsOptions, helmetOptions, generalLimiter, requestLogger, healthCheck } = require('./middleware/security')

// 导入路由
const apiRoutes = require('./routes')

// 导入模型（确保模型被注册到Sequelize）
require('./models/ChapterConfig')

// 创建Express应用
const app = express()

// 信任代理（如果在反向代理后面）
app.set('trust proxy', 1)

// 基础中间件
app.use(compression()) // 响应压缩
app.use(helmet(helmetOptions)) // 安全头
app.use(cors(corsOptions)) // CORS
app.use(express.json({ limit: '10mb' })) // JSON解析
app.use(express.urlencoded({ extended: true, limit: '10mb' })) // URL编码解析

// 请求日志
app.use(requestLogger)

// 速率限制
app.use(generalLimiter)

// 健康检查（在所有其他路由之前）
app.use('/health', healthCheck)

// 静态文件服务
app.use('/public', express.static(path.join(__dirname, 'public')))

// 保留原有的xmind文件API（向后兼容）
app.get('/api/xmind-files', (req, res) => {
  try {
    // 获取Vue项目的public/xmind目录路径
    const xmindDir = path.join(__dirname, 'public/xmind')
    console.log('XMind目录路径:', xmindDir)
    // 检查目录是否存在
    if (!fs.existsSync(xmindDir)) {
      return res.status(404).json({ error: 'XMind目录不存在' })
    }
    
    // 读取目录中的文件
    const files = fs.readdirSync(xmindDir)
    
    // 过滤出.xmind文件
    const xmindFiles = files
      .filter(file => file.endsWith('.xmind'))
      .map(fileName => ({
        name: fileName,
        title: fileName.replace('.xmind', ''),
        path: `/xmind/${fileName}`
      }))
    
    res.json(xmindFiles)
  } catch (error) {
    console.error('获取XMind文件列表失败:', error)
    res.status(500).json({ error: '服务器内部错误' })
  }
})

// 保留原有的环境检查API（向后兼容）
app.get('/api/check-environment', async (req, res) => {
  try {
    const { exec } = require('child_process')
    const util = require('util')
    const execPromise = util.promisify(exec)
    
    const tools = [
      { name: 'Node.js', command: 'node --version' },
      { name: 'npm', command: 'npm --version' },
      { name: 'Vue CLI', command: 'vue --version' },
      { name: 'Git', command: 'git --version' },
      { name: 'VS Code', command: 'code --version' }
    ]

    const results = []

    for (const tool of tools) {
      try {
        const { stdout, stderr } = await execPromise(tool.command)
        const version = stdout.trim().split('\n')[0] // 取第一行作为版本号
        results.push({
          name: tool.name,
          status: 'installed',
          version: version
        })
      } catch (error) {
        results.push({
          name: tool.name,
          status: 'not-installed',
          version: '未安装'
        })
      }
    }

    // Chrome DevTools 特殊处理（无法通过命令行检查）
    results.push({
      name: 'Chrome DevTools',
      status: 'installed',
      version: 'Latest (需手动确认)'
    })

    res.json({
      success: true,
      tools: results
    })
  } catch (error) {
    console.error('环境检查失败:', error)
    res.status(500).json({ error: '服务器内部错误' })
  }
})

// API路由
app.use('/api', apiRoutes)

// 根路径重定向到API文档
app.get('/', (req, res) => {
  res.redirect('/api')
})

// 404处理
app.use(notFoundHandler)

// 错误处理
app.use(errorHandler)

// 确保数据目录存在
function ensureDataDirectory() {
  const dataDir = path.join(__dirname, 'data')
  if (!fs.existsSync(dataDir)) {
    fs.mkdirSync(dataDir, { recursive: true })
    logger.info('数据目录已创建', { path: dataDir })
  }
  
  // 确保db.json文件存在
  const dbPath = path.join(__dirname, 'db.json')
  if (!fs.existsSync(dbPath)) {
    const initialData = {
      users: [],
      aiConfigs: [],
      chatSessions: [],
      chatMessages: [],
      systemConfigs: []
    }
    fs.writeFileSync(dbPath, JSON.stringify(initialData, null, 2))
    logger.info('数据库文件已创建', { path: dbPath })
  }
}

// 优雅关闭处理
function gracefulShutdown(signal) {
  logger.info(`收到 ${signal} 信号，开始优雅关闭...`)
  
  server.close((err) => {
    if (err) {
      logger.error('服务器关闭时发生错误', err)
      process.exit(1)
    }
    
    logger.info('服务器已优雅关闭')
    process.exit(0)
  })
  
  // 强制关闭超时
  setTimeout(() => {
    logger.error('强制关闭服务器')
    process.exit(1)
  }, 10000)
}

// 启动服务器
function startServer() {
  try {
    // 验证配置
    config.validateConfig()
    
    // 确保数据目录存在
    ensureDataDirectory()
    
    const PORT = config.server.port
    const HOST = config.server.host
    
    const server = app.listen(PORT, HOST, () => {
      logger.info('服务器启动成功', {
        port: PORT,
        host: HOST,
        env: process.env.NODE_ENV || 'development',
        pid: process.pid,
        version: require('./package.json').version
      })
      
      // 输出启动信息
      console.log(`\n🚀 知识库后端服务已启动`)
      console.log(`📍 服务地址: http://${HOST}:${PORT}`)
      console.log(`📚 API文档: http://${HOST}:${PORT}/api/docs`)
      console.log(`💚 健康检查: http://${HOST}:${PORT}/health`)
      console.log(`🌍 环境: ${process.env.NODE_ENV || 'development'}`)
      console.log(`📝 日志级别: ${config.logging.level}`)
      console.log(`\n按 Ctrl+C 停止服务器\n`)
    })
    
    // 设置服务器超时
    server.timeout = 30000 // 30秒
    server.keepAliveTimeout = 5000 // 5秒
    server.headersTimeout = 6000 // 6秒
    
    // 导出server实例供其他模块使用
    module.exports.server = server
    
    // 注册优雅关闭处理
    process.on('SIGTERM', () => gracefulShutdown('SIGTERM'))
    process.on('SIGINT', () => gracefulShutdown('SIGINT'))
    
    // 处理未捕获的异常
    process.on('uncaughtException', (err) => {
      console.error('Uncaught Exception:', err)
      console.error('Stack:', err.stack)
      logger.error('未捕获的异常', err)
      gracefulShutdown('uncaughtException')
    })
    
    process.on('unhandledRejection', (reason, promise) => {
      console.error('Unhandled Rejection at:', promise, 'reason:', reason)
      logger.error('未处理的Promise拒绝', {
        reason,
        promise
      })
      gracefulShutdown('unhandledRejection')
    })
    
    return server
    
  } catch (error) {
    logger.error('服务器启动失败', error)
    process.exit(1)
  }
}

// 如果直接运行此文件，则启动服务器
if (require.main === module) {
  startServer()
}

// 导出app实例供测试使用
module.exports = app